package com.fas.hehe.config.service;

import java.util.ArrayList;
import java.util.List;

import com.fas.core.BaseService;
import com.fas.core.constant.R;
import com.fas.core.plugin.jfinal.kit.ModelKit;
import com.fas.core.util.sequence.Sequence;
import com.fas.hehe.config.model.DictionaryData;
import com.jfinal.aop.Before;
import com.jfinal.plugin.activerecord.Db;
import com.jfinal.plugin.activerecord.tx.Tx;

/**
 * 
 * 字典数据业务处理类
 *
 * @Copyright: Copyright (c) 2016 FAS
 * @anthor yixiaoping<thinker1013@163.com>
 * @since 2016年1月23日 下午2:12:00
 * @version V1.0
 */
public class DictionaryDataService extends BaseService {

	/**
	 * 
	 * @Title:根据字典类别，查询类别字典数据
	 * @Description:
	 * @param dictCode
	 *            字典类别编码
	 * @return
	 * @anthor yixiaoping<thinker163@163.com>
	 * @date 2016年1月23日 下午2:12:16
	 */
	public List<DictionaryData> findDictionaryDataByGroupCode(String dictCode) {
		String sql = "select * from config_dictionary_data where dict_code = ? and available = ? order by priority asc";
		return DictionaryData.dao.find(sql, dictCode, R.Dict.STATUS_AVAILABLE);
	}

	/**
	 * 
	 * @Title: 修改字典数据优先级别（显示顺序）
	 * @Description:
	 * @param dictCode
	 *            字典类别编码
	 * @param type
	 *            操作类型： up：上移 ，优先级别（显示顺序）加1 down：下移，优先级别（显示顺序）减1
	 * 
	 * @param priority
	 *            优先级别（显示顺序）
	 * @return
	 * @anthor yixiaoping<thinker163@163.com>
	 * @date 2016年1月23日 下午2:13:03
	 */
	@Before(Tx.class)
	public boolean changeDictionaryDataPriority(String dictCode, String type, int priority) {
		int otherPriority = 0;
		final String UP = "up";
		if (UP.equals(type)) {
			otherPriority = priority - 1;
		} else {
			otherPriority = priority + 1;
		}
		String sql = "select * from config_dictionary_data where dict_code = ? and priority = ?";
		DictionaryData curData = DictionaryData.dao.findFirst(sql, dictCode, priority);
		DictionaryData otherOrg = DictionaryData.dao.findFirst(sql, dictCode, otherPriority);
		if (curData != null) {
			curData.setPriority(otherPriority);
			curData.update();
		}
		if (otherOrg != null) {
			otherOrg.setPriority(priority);
			otherOrg.update();
		}
		return true;
	}

	/**
	 * 
	 * @Title: 根据ID，删除字典数据
	 * @Description: 逻辑删除，将状态改为0-不可用；不进行物理删除
	 * @param id
	 *            字典数据ID
	 * @return
	 * @anthor yixiaoping<thinker163@163.com>
	 * @date 2016年1月23日 下午2:16:46
	 */
	@Before(Tx.class)
	public boolean deleteDictionaryDataById(Long id) {
		DictionaryData oldData = DictionaryData.dao.findById(id);
		DictionaryData newData = new DictionaryData();
		ModelKit.clone(oldData, newData);

		oldData.set("available", R.Dict.STATUS_UNAVAILABLE);
		oldData.update();
		this.saveOperateLog(R.OperType.UPDATE, newData, oldData, this.getLoginUser());

		autoResetPriority(oldData.getDictCode());
		return true;
	}

	/**
	 * 
	 * @Title:autoResetPriority
	 * @Description: <pre>
	 *      重新设置字典类别所有字典数据的优先级别 ,通常在删除字典数据之后操作。
	 * 				 1）  将子机构中，状态为“0-不可用”的记录优先级别全部更新为-1 
	 *               2) 将子机构中，状态为“1-可用”的记录，优先级别重新设置，但不改变原先这些值的前后顺序，
	 *               只是让Priority值从1开始逐1递增
	 * 	
	 * 				例如：   ID   状态     优先级                                   重置后状态为： ID   状态     优先级     
	 *             		101    1    1                     101    1    1
	 *                  102    1    2					  102    1    2
	 *                  103    0    3					  104    1    3
	 *                  104    1    4				      106    1    4
	 *                  105    0    5					  103    0    -1
	 *                  106    1    6					  105    0    -1
	 * </pre>
	 * @param dictCode
	 *            参数说明 字典类别编码
	 * @return void 返回类型
	 * @throws
	 * @anthor yixiaoping<thinker163@163.com>
	 * @date 2016年1月28日 下午10:36:39
	 */
	public void autoResetPriority(String dictCode) {
		// 将状态为"不可用"的记录，优先级全部设置为-1
		String updateSql = "update config_dictionary_data set priority = ? where dict_code = ? and available =?";
		Db.update(updateSql, R.Const.DEFAULT_PRIORITY_VAL, dictCode, R.Dict.STATUS_UNAVAILABLE);

		// 重新设置状态为"可用"记录的优先级别值，但先后顺序不变
		String selectSql = "select * from config_dictionary_data where dict_code =? and available =?";
		List<DictionaryData> list = DictionaryData.dao.find(selectSql, dictCode, R.Dict.STATUS_AVAILABLE);
		ArrayList<DictionaryData> newList = new ArrayList<DictionaryData>();
		for (int i = 0; i < list.size(); i++) {
			DictionaryData data = list.get(i);
			data.setPriority(i + 1);
			newList.add(data);
		}
		list = null;
		Db.batchUpdate(newList, R.Const.DB_BATCH_SIZE);
	}

	/**
	 * 
	 * @Title:查找某个类别的字典数据列表中，优先级别最大的值
	 * @Description:
	 * @param dictCode
	 *            字典类别编码
	 * @return
	 * @anthor yixiaoping<thinker163@163.com>
	 * @date 2016年1月23日 下午2:17:47
	 */
	public int findMaxDataPrioritybyPid(String dictCode) {
		String sql = "select max(priority)  as priority from config_dictionary_data where dict_code = ? and available = ?";
		DictionaryData data = DictionaryData.dao.findFirst(sql, dictCode, R.Dict.STATUS_AVAILABLE);
		return data.get("priority") == null ? 0 : data.getInt("priority");
	}

	/**
	 * 
	 * @Title:保存字典数据
	 * @Description:
	 * @param data
	 *            字典数据对象
	 * @return
	 * @anthor yixiaoping<thinker163@163.com>
	 * @date 2016年1月23日 下午2:18:40
	 */
	@Before(Tx.class)
	public boolean saveDictionaryData(DictionaryData data) {
		Long id = data.getId();
		if (id == null) {
			data.setId(Sequence.getSequence());
			data.setAvailable(Integer.valueOf(R.Dict.STATUS_AVAILABLE));
			data.setIsFixed(Integer.valueOf(R.Dict.IS_OR_NOT_Y));
			int priority = this.findMaxDataPrioritybyPid(data.getDictCode()) + 1;
			data.setPriority(priority);
			data.save();
			this.saveOperateLog(R.OperType.ADD, data, null, this.getLoginUser());
		} else {
			DictionaryData oldData = DictionaryData.dao.findById(id);
			DictionaryData newData = new DictionaryData();
			ModelKit.clone(oldData, newData);

			newData.setDictdataName(data.getDictdataName());
			newData.setDictdataValue(data.getDictdataValue());
			newData.setTranClass(data.getTranClass());

			newData.update();
			this.saveOperateLog(R.OperType.UPDATE, newData, oldData, this.getLoginUser());
			return true;
		}
		return true;
	}

	/**
	 * 
	 * @Title:根据ID查询字典数据对象
	 * @Description:
	 * @param id
	 *            字典数据ID
	 * @return
	 * @anthor yixiaoping<thinker163@163.com>
	 * @date 2016年1月23日 下午2:19:03
	 */
	public DictionaryData findDictionaryDataById(Long id) {
		return DictionaryData.dao.findById(id);
	}
}
